1、删除链表得重复节点
思想：创建一个头节点，然后双指针
class Solution {
public:
    ListNode* deleteDuplication(ListNode* pHead) {
        if(pHead==nullptr||pHead->next==nullptr)
            return pHead;
        //定义一个头节点
        ListNode* head=new ListNode(-1);
        head->next=pHead;
        ListNode* cur=head->next;
        ListNode* prev=head;
        while(cur)
        {
            if(cur->next&&cur->val==cur->next->val)
            {
                while(cur->next&&cur->next->val==cur->val)
                {
                    cur=cur->next;
                }
                cur=cur->next;
                prev->next=cur;
            }
            else
            {
                prev=cur;
                cur=cur->next;
            }
        }
        return head->next;
    }
};
2、数组得逆序对
思想：归并排序思想：合并的时候，比较2个小数组得元素大小即可
class Solution {
public:
    int sort(vector<int>& data,vector<int>& p,int l,int r)
    {
        if(l>=r)
            return 0;
        int mid=(l+r)/2;
        long long count=sort(data,p,l,mid)+sort(data,p,mid+1,r);
        //将data里数据拷贝到p中,方便排序 将p的数据插入到data中
        for(int i=l;i<=r;i++)
        {
            p[i]=data[i];
        }
        //表示拆分的2个小数组的下标
        int i=l,j=mid+1;
        for(int k=l;k<=r;k++)
        {
            if(i==mid+1)
            {
                data[k]==p[j++];
            }
            else if(j==r+1||p[i]<=p[j])
            {
                data[k]=p[i++];
            }
            else
            {
                data[k]=p[j++];
                count+=(mid-i+1);
            }
        }
        return (int)(count%1000000007);
    }
    int InversePairs(vector<int> data) {
        if(data.size()<2)
            return 0;
        //开辟一块空间，归并做法
        vector<int> p(data.size(),0);
        int count=sort(data,p,0,data.size()-1);
        return count;
    }
};